//package RK;
//
///**
// * 字符串匹配RK算法，BF算法的升级版本
// */
//public class RK {
//
//    /**
//     * 假设只匹配字母，所以d等于26
//     * @param str 主串
//     * @param pattern 模式串
//     * @return
//     */
//    public static int rabinKarp(String str, String pattern){
//        int size1 = str.length();
//        int size2 = pattern.length();
//
//        //哈希时需要用到进制计算，这里只涉及26个字母所以使用26进制
//        int d = 26;
//        //防止hash之后的值超出int范围，对最后的hash值取模
//        //q取随机素数，满足q*d < INT_MAX即可
//        int q = 144451;
//
//        //str子串的hash值
//        int strCode = str.charAt(0) - 'a';
//        //pattern的hash值
//        int patternCode = pattern.charAt(0) - 'a';
//        //d的size2-1次幂，hash计算时，公式中会用到
//        int h = 1;
//
//        //计算sCode、pCode、h
//        for (int i = 1; i < size2; i++) {
//            patternCode = (d*patternCode + pattern.charAt(i)-'a') % q;
//            //计算str第一个子串的hash
//            strCode = (d*strCode + str.charAt(i)-'a') % q;
//            //h = (h*d) % q;
//        }
//
//        //最大需要匹配的次数
//        int frequency = size1 - size2 + 1;
//
//        //字符串开始匹配，对patternCode和strCode开始比较，并更新strCode的值
//        for (int i = 0; i < frequency; i++) {
//            if(strCode == patternCode && ensureMatching(i, str, pattern)){
//                return i;
//            }
//            //更新strCode的值，即计算str[i+1,i+m-1]子串的hashCode
//            if(i< frequency && i+size2<frequency)
//            strCode = ((strCode - h*(str.charAt(i)-'a'))*d + str.charAt(i+size2) - 'a');
//        }
//        return -1;
//    }
//
//    /**
//     * hash值一样并不能完全确保字符串一致，所以还需要进一步确认
//     * @param i hash值相同时字符串比对的位置
//     * @param pattern 模式串
//     * @return
//     */
//    private static boolean ensureMatching(int i, String str, String pattern) {
//        String strSub = str.substring(i, i+pattern.length());
//        return strSub.equals(pattern);
//    }
//
//    public static void main(String[] args) {
//        String str = "abcabcabc";
//        String pattern = "ca";
//        System.out.println("第一次出现的位置:" + rabinKarp(str, pattern));
//    }
//}


package BM;


import java.util.Scanner;

/**
 * BM算法实现
 */
public class BM {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str1=sc.next();
        String str2=sc.next();
        int ret=pattern(str1,str2);
        System.out.println(ret);
    }

    /**
     * 算法匹配
     */
    public static int pattern(String pattern, String target) {
        int tLen = target.length();
        int pLen = pattern.length();

        if (pLen > tLen) {
            return -1;
        }

        int[] bad_table = build_bad_table(pattern);// 1,3,5,6,2,
        int[] good_table = build_good_table(pattern);// 1,8,5,10,11,12,13

        for (int i = pLen - 1, j; i < tLen;) {
            System.out.println("跳跃位置：" + i);
            for (j = pLen - 1; target.charAt(i) == pattern.charAt(j); i--, j--) {
                if (j == 0) {
                    System.out.println("匹配成功，位置：" + i);
//					i++;   // 多次匹配
//					break;
                    return i;
                }
            }
            i += Math.max(good_table[pLen - j - 1], bad_table[target.charAt(i)]);
        }
        return -1;
    }

    /**
     * 字符信息表
     */
    public static int[] build_bad_table(String pattern) {
        final int table_size = 256;
        int[] bad_table = new int[table_size];
        int pLen = pattern.length();

        for (int i = 0; i < bad_table.length; i++) {
            bad_table[i] = pLen;  //默认初始化全部为匹配字符串长度
        }
        for (int i = 0; i < pLen - 1; i++) {
            int k = pattern.charAt(i);
            bad_table[k] = pLen - 1 - i;
        }
//		for (int i : bad_table) {
//			if (i != 7) {
//				System.out.print(i + ",");
//			}
//		}
        return bad_table;
    }

    /**
     * 匹配偏移表。
     *
     * @param pattern
     *            模式串
     * @return
     */
    public static int[] build_good_table(String pattern) {
        int pLen = pattern.length();
        int[] good_table = new int[pLen];
        int lastPrefixPosition = pLen;

        for (int i = pLen - 1; i >= 0; --i) {
            if (isPrefix(pattern, i + 1)) {
                lastPrefixPosition = i + 1;
            }
            good_table[pLen - 1 - i] = lastPrefixPosition - i + pLen - 1;
        }

        for (int i = 0; i < pLen - 1; ++i) {
            int slen = suffixLength(pattern, i);
            good_table[slen] = pLen - 1 - i + slen;
        }
        return good_table;
    }

    /**
     * 前缀匹配
     */
    private static boolean isPrefix(String pattern, int p) {
        int patternLength = pattern.length();
        for (int i = p, j = 0; i < patternLength; ++i, ++j) {
            if (pattern.charAt(i) != pattern.charAt(j)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 后缀匹配
     */
    private static int suffixLength(String pattern, int p) {
        int pLen = pattern.length();
        int len = 0;
        for (int i = p, j = pLen - 1; i >= 0 && pattern.charAt(i) == pattern.charAt(j); i--, j--) {
            len += 1;
        }
        return len;
    }

}

